home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / parser / control.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-18  |  7.7 KB  |  438 lines
  1. # include    <ingres.h>
  2. # include    <aux.h>
  3. # include    <symbol.h>
  4. # include    <tree.h>
  5. # include    "parser.h"
  6. # include    <pv.h>
  7. # include    "scanner.h"
  8. # include    <sccs.h>
  9. # include    <../ovqp/ovqp.h>
  10. # include    <errors.h>
  11.  
  12. SCCSID(@(#)control.c    8.4    1/22/88)
  13.  
  14. /*
  15. **  CONTROL.C -- -- collection of control functions for the parser
  16. **
  17. **    These routines administrate the operation of the parser for internal
  18. **    sequencing.  There are 2 pairs of routines, one pair for each
  19. **    quel statement, and one for each go-block, and there is one
  20. **    routine to finish retrieve statements.
  21. **
  22. **    Defines:
  23. **        startgo        -- initialize for a go-block
  24. **        init_quelst    -- initialize for a quel statement
  25. **        endquelst    -- clean up after a quel statement
  26. **        endretrieve    -- clean up after a retrieve
  27. **        endgo        -- clean up after a go-block
  28. **
  29. **    Trace Flags:
  30. **        control.c ~~ 48, 49
  31. **
  32. **    History:
  33. **        6 Jun 80 (jiw)        modified and redocumented for 6.3
  34. **        15 Jan 79 (rick)    collected and documented more
  35. **        ancient history
  36. */
  37.  
  38. /*
  39. ** INIT_QUELST -- set vbles for default mode before each quel statement
  40. **
  41. **    Parameters:
  42. **        none
  43. **
  44. **    Returns:
  45. **        nothing
  46. **
  47. **    Trace Flags:
  48. **        init_quelst ~~ 48.0
  49. */
  50.  
  51. extern int Ingerr;
  52.  
  53. int
  54. init_quelst()
  55. {
  56.     extern int    neederr();
  57.     extern         ack_err();
  58.     extern int    Err_current;
  59.     extern int    Pars;
  60.     extern int    Lcase;
  61.     extern int    Dcase;
  62.     extern int    Agflag;
  63.     extern int    Opflag;
  64.     extern int    Resrng;
  65.     extern int    Qlflag;
  66.  
  67. #    ifdef    xPTR3
  68.     tTfp(48, 0, "Init_quelst\n");
  69. #    endif
  70.  
  71.     Err_current = 0;            /* no error yet */
  72.     Pars = 1;                /* set scanner into "parser" mode */
  73.     Lcase = Dcase;                /* set case mapping to default */
  74.     Agflag = 0;                /* reset aggregate flag */
  75.     Opflag = 0;                /* reset qmode flag */
  76.     Resrng = -1;                /* reset result relation slot */
  77.     Qlflag = 0;                /* reset qualification flag */
  78.  
  79.     initp();                /* initialize parameter vector */
  80.     init_qt();                /* assume we have qrytree */
  81.  
  82.     freesym();                /* free symbol table space */
  83.     rngreset();                /* reset used bits in range tbl */
  84.  
  85.     return (1);
  86. }
  87.  
  88. /*
  89. ** ENDQUELST -- finish command checking and processing for each quel statement
  90. **
  91. **    Parameters:
  92. **        op -- the type of query to finish up
  93. **
  94. **    Returns:
  95. **        nothing
  96. **
  97. **    Trace Flags:
  98. **        endquelst ~~ 48.4, 48.5
  99. */
  100.  
  101. int
  102. endquelst(op)
  103. register int    op;
  104. {
  105.     register int            i;
  106.     char                ibuf[2];    /* two char buffer for index keys */
  107.  
  108.     extern char            *Indexspec;
  109.     extern char            *Indexname;
  110.     extern int            Equel;
  111.     extern int            Agflag;
  112.  
  113.     extern struct lasttok        *Lasttok;
  114.  
  115.     extern short            yyerrflag;
  116.     extern int            Err_current;
  117.     extern int            Err_fnd;
  118.  
  119.     extern DESC            Attdes;
  120.     extern DESC            Reldesc;
  121.     extern int            Rsdmno;
  122.     extern PARRNG            Parrng[];
  123.     extern int            Resrng;
  124.  
  125.     extern int            printtrail();
  126.  
  127. #    ifdef    xPTR3
  128.     if (tTf(48, 4))
  129.         prvect(0, getp());
  130. #    endif
  131.  
  132.     /* check next token for GOVAL if the next token has been read */
  133.     if (!Err_current && !yyerrflag)
  134.         switch (op)
  135.         {
  136.            case mdSAVE:
  137.            case mdCOPY:
  138.            case mdCREATE:
  139.  
  140. #          ifdef    DISTRIB
  141.           case mdDCREATE:
  142. #          endif
  143.  
  144.           case mdINDEX:
  145.           case mdRANGE:
  146.           case mdSTOP:
  147.             break;
  148.  
  149.           default:
  150.             /* has vble ending and therefore must detect valid end of command */
  151. #            ifdef    xPTR3
  152.             tTfp(48, 5, "before NXTCMDERR\n");
  153. #            endif
  154.             if (Lastok.tokop != GOVAL)
  155.                 /* next token not start of command */
  156.                 par_error(NXTCMDERR, WARN, 0);
  157.             break;
  158.         }
  159.  
  160.     if (Agflag >= MAXAGG)
  161.         /* too many aggregates */
  162.         par_error(AGGXTRA, WARN, 0);
  163.  
  164.     /* command ok so far, finish up */
  165.     if (!Err_fnd)
  166.     {
  167.         switch (op)
  168.         {
  169.           case mdINDEX:
  170.             if (tTf(48, 5))
  171.                 printf("mdINDEX\n");
  172.             if (call(op, NULL) < 0)
  173.                 ack_err();
  174.             if (tTf(48, 5))
  175.                 printf("after call to call\n");
  176.  
  177.             if (Ingerr)
  178.             {
  179.                 if (tTf(48, 5))
  180.                     printf("Ingerr = %d\n", Ingerr);
  181.  
  182.                 endgo();
  183.  
  184.                 return (-1);
  185.             }
  186.  
  187.             if (Indexspec)
  188.             {
  189.                 initp();
  190.                 setp(PV_STR, Indexname);    /* type */
  191.                 setp(PV_STR, Indexspec);    /* specs */
  192.                 setp(PV_STR, "num");
  193.                 for (i = 1; i <= Rsdmno; i++)
  194.                 {
  195.                     ibuf[0] = i & I1MASK;
  196.                     ibuf[1] = '\0';
  197.                     setp(PV_STR, ibuf);
  198.                 }
  199.                 if (call(mdMODIFY, NULL) < 0)
  200.                     ack_err();
  201.             }
  202.             break;
  203.  
  204.           case mdRETR:
  205.           case mdRET_UNI:
  206.           case mdVIEW:
  207.             if (Resrng >= 0)        /* implies result reln */
  208.             {
  209.                 if (calln(mdCREATE, NULL) < 0)
  210.                     ack_err();
  211.  
  212.                 cleanrel(&Attdes);
  213.  
  214.                 if ((i = openr(&Reldesc, OR_RELTID, trim_relname(Parrng[Resrng].vardesc.reldum.relid))) < 0)
  215.                     syserr("result reln: error in openr '%d'", i);
  216.                 
  217.                 rngent(R_INTERNAL, "", &Reldesc);
  218.             }
  219.             else if (!Equel)
  220.                 /* need to print header */
  221.                 header(getp());
  222.  
  223.             if (Ingerr)
  224.             {
  225.                 /*
  226.                 ** might be nice to back out the create already done
  227.                 ** by this point so that the user doesn't need to
  228.                 */
  229.                 resetp();
  230.  
  231.                 endgo();    /* abort rest of go-block */
  232.  
  233.                 return (-1);
  234.             }
  235.             initp();
  236.             /* fall through */
  237.  
  238.           case mdAPP:
  239.           case mdDEL:
  240.           case mdREPL:
  241.             if (op != mdVIEW)
  242.             {
  243.                 call_tree(op, mdQRY, ack_err);
  244.  
  245.                 if (op == mdRETR || op == mdRET_UNI)
  246.                     endretrieve(ack_err);
  247.  
  248.                 Patnum = 0;
  249.                 for (i = 0; i < PATNUM; i++)
  250.                     if (Pats[i].string)
  251.                     {
  252.                         free(Pats[i].string);
  253.                         Pats[i].string = NULL;
  254.                         Pats[i].len = 0;
  255.                     }
  256.                 break;
  257.             }
  258.  
  259. #          ifdef DISTRIB
  260.           case mdDISTRIB:
  261.             op = mdVIEW;
  262. #          endif
  263.             /* else, do VIEW */
  264.             setp(PV_STR, trim_relname(Parrng[Resrng].vardesc.reldum.relid));
  265.  
  266.           case mdINTEG:
  267.           case mdPROT:
  268.             call_tree(op, op, ack_err);
  269.             break;
  270.  
  271.           case mdCREATE:
  272.  
  273. #          ifdef    DISTRIB
  274.           case mdDCREATE:
  275. #          endif
  276.  
  277.           case mdDESTROY:
  278.           case mdMODIFY:
  279. # ifdef    V6POINT3COMPAT
  280.             /* in this case, if an error in the dbu's will not */
  281.             /* cause other processing to halt */
  282.             call(op, NULL);
  283. # else
  284.             if (call(op, NULL) < 0)
  285.                 ack_err();
  286. # endif
  287.             cleanrel(&Attdes);
  288.             break;
  289.  
  290.           case mdCOPY:
  291.           case mdHELP:
  292.           case mdPRINT:
  293.           case mdSAVE:
  294.           case mdDISPLAY:
  295.           case mdREMQM:
  296. # ifdef    V6POINT3COMPAT
  297.             call(op, NULL);
  298. # else
  299.             if (call(op, NULL) < 0)
  300.                 ack_err();
  301. # endif
  302.             break;
  303.  
  304.           case mdSTOP:
  305.           case mdRANGE:
  306.             break;
  307.  
  308.           default:
  309.             syserr("Endquelst: bad op %d", op);
  310.         }
  311.     }
  312.     
  313.     /* refresh relstat bits if necessary */
  314.     rngfresh(op);
  315.     if (init_quelst() < 0)
  316.         return (-1);
  317.  
  318.     return (1);
  319. }
  320.  
  321. /*
  322. ** STARTGO -- do whatever needs doing to set up a go-block
  323. **
  324. **    Parameters:
  325. **        none
  326. **
  327. **    Returns:
  328. **        nothing
  329. **
  330. **    Trace Flags:
  331. **        startgo ~~ 48.8
  332. */
  333.  
  334. extern int Ingerr, Err_fnd, Equel; 
  335.  
  336. startgo()
  337. {
  338.     extern int    yyline;
  339.  
  340. #    ifdef    xPTR3
  341.     tTfp(48, 8, "startgo\n");
  342. #    endif
  343.  
  344.     /* initialize for go-block */
  345.     get_scan(PRIME);        /* prime the scanner input */
  346.     Err_fnd = 0;        /* no errors have been found yet */
  347.     Ingerr = 0;
  348.  
  349.     if (init_quelst() < 0)    /* most other init's are done for each statement */
  350.         return (-1);
  351.  
  352.     yyline = 1;        /* reset line counter */
  353.  
  354.     return (1);
  355. }
  356.  
  357. /*
  358. **  ENDGO -- do whatever needs doing to clean up after a go block
  359. **
  360. **    Parameters:
  361. **        none
  362. **
  363. **    Returns:
  364. **        nothing
  365. **
  366. **    Trace Flags:
  367. **        endgo ~~ 48.12
  368. */
  369.  
  370. endgo()
  371. {
  372. #    ifdef    xPTR3
  373.     tTfp(48, 12, "endgo\n");
  374. #    endif
  375.  
  376.     if (!Equel && Err_fnd > 1)
  377.         error(SUMMARY, iocv(Err_fnd), 0);
  378.  
  379.     get_scan(SYNC);
  380.  
  381.     resetp();
  382. }
  383.  
  384. /*
  385. **  ENDRETRIEVE -- finishes any sort of retrieve
  386. **
  387. **    Endretrieve either creates a result relation or prints a trailer
  388. **
  389. **    Parameters:
  390. **        err_fcn -- function to pass to call
  391. **
  392. **    Returns:
  393. **        nothing
  394. **
  395. **    Trace Flags:
  396. **        endretrieve ~~ 48.14    
  397. **
  398. **    History:
  399. **        June '80 -- (jiw) broken off from call_tree
  400. */    
  401.  
  402. endretrieve(err_fcn)
  403. int    (*err_fcn)();
  404. {
  405.     extern int        Resrng;
  406.     extern char        *Relspec;
  407.     extern PARRNG        Parrng[];
  408.     extern int        Hdr;
  409.  
  410.     if (Resrng >= 0)
  411.     {
  412.         if (Relspec)
  413.         {
  414.             initp();
  415.  
  416.             setp(PV_STR, trim_relname(Parrng[Resrng].vardesc.reldum.relid));
  417.             setp(PV_STR, Relspec);
  418.             if (call(mdMODIFY, err_fcn) < 0)
  419.                 (*err_fcn)();
  420.         }
  421.     }
  422.     else if (!Equel)
  423.     {
  424.         printeh();
  425.         Hdr = FALSE;
  426.     }
  427. }
  428.  
  429. printtrail()
  430. {
  431.     extern int    Equel;
  432.  
  433.     if (!Equel)
  434.         printeh();
  435.  
  436.     return (-1);
  437. }
  438.